import { Controller } from 'egg';
import {Op} from "sequelize";
export default class  SolutionController extends Controller {
    
    //解决方案列表接口
    /**
     * @api {get} /manage/solution_list 解决方案列表
     * @apiName manageSolutionList
     * @apiGroup Solution
     * @apiVersion 1.0.0
     * @apiDescription 解决方案列表
     * @apiParam {String} keyword  关键字查询
     * @apiParam {Number} page  页面位置
     * @apiParam {Number} page_size  页面尺寸
     * @apiParam {Number} category_id  类型ID
     * @apiParam {Number} sub_id  子类型ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * @apiSuccess {Object} data 返回结果
     * @apiSuccess {Object} data.data_info 解决方案列表
     * @apiSuccess {Number} data.data_info.solution_id 解决方案ID
     * @apiSuccess {String} data.data_info.solution_name 解决方案名称
     * @apiSuccess {String} data.data_info.create_time 创建时间
     * @apiSuccess {String} data.data_info.category_name 解决方案类型名称
     * @apiSuccess {String} data.data_info.sub_name 解决方案子类型名称
     * @apiSuccess {Number} data.data_info.sub_id 解决方案子类型Id
     * @apiSuccess {Number} data.data_info.category_id 解决方案类型ID
     * 
     */
    /**
     * 分页查询所有解决方案
     * 参数：
     *  condition 检索条件
     * 输出：
     * {Number} code 返回状态码 0失败  200成功
     * {String} message 返回状态对应提示消息
     * {Object} data 返回结果
     * {Object} data.data_info 解决方案列表
     * {Number} data.data_info.solution_id 解决方案ID
     * {String} data.data_info.solution_name 解决方案名称
     * {String} data.data_info.create_time 创建时间
     * {String} data.data_info.category_name 解决方案类型名称
     * {String} data.data_info.sub_name 解决方案子类型名称
     * {Number} data.data_info.sub_id 解决方案子类型Id
     * {Number} data.data_info.category_id 解决方案类型ID
     * 过程：
     *  构建分页查询条件
     *  分页查询数据，分页结果处理逻辑，返回结果
     */
    async list(){
        let {ctx}=this;
        const {query}=ctx.request;
        try {
            let condition:any={}
            if(query.keyword){
                let keyword=query.keyword;
                condition['solution_name']={[Op.like]: '%'+ keyword +'%'};
            }
            
            if(query.category_id){
                condition['category_id']=query.category_id;
            }
            if(query.sub_id){
                condition['sub_id']=query.sub_id;
            }
            let order_condition=[
                ['create_time', 'DESC']
            ];
            //ctx.helper.sort_order(order_condition);
            let solution_list=await ctx.service.solution.find_and_count_all(condition,order_condition,query);
            ctx.body=solution_list
        } catch (error) {
            ctx.body=ctx.helper.error_result("查询异常");
        }
    }
    //解决方案
    /**
     * @api {get} /manage/solution_info 解决方案详情
     * @apiName manageSolutionInfo
     * @apiGroup Solution
     * @apiVersion 1.0.0
     * @apiDescription 解决方案详情
     * @apiParam {Number} solution_id  解决方案ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * @apiSuccess {Object} data 查询结果结构
     * @apiSuccess {String} data.solution_name 解决方案名称
     * @apiSuccess {String} data.solution_id 解决方案ID
     * @apiSuccess {Object[]} data.resource 解决方案内容数组
     * @apiSuccess {Number} data.resource.resource_id 解决方案内容资源ID
     * @apiSuccess {String} data.resource.resource_name 解决方案内容资源名称
     * @apiSuccess {String} data.resource.resource_url 资源路径
     * @apiSuccess {String} data.resource.resource_content 解决方案内容资源对应视频路径
     * @apiSuccess {Number} data.category_id 解决方案分类ID
     * @apiSuccess {String} data.category_name 解决方案分类名称
     * @apiSuccess {String} data.sub_name 解决方案子分类名称
     * @apiSuccess {Number} data.sub_id 解决方案子分类ID
     * @apiSuccess {String} data.create_time 解决方案创建时间
     * 
     */
    async info(){
        let {ctx}=this;
        const {query}=ctx.request;
        let solution_id=query.solution_id;
        if(!solution_id){
            return ctx.body=ctx.helper.error_result("没有指定需要查询的解决方案ID")
        }
        let  result=await ctx.service.solution.find_one({solution_id});
        ctx.body=result
    }
    
    //解决方案修改
    /**
     * @api {get} /manage/solution_update 解决方案修改
     * @apiName manageSolutionUpdate
     * @apiGroup Solution
     * @apiVersion 1.0.0
     * @apiDescription 解决方案修改
     * @apiParam {Number} solution_id  解决方案ID
     * @apiParam {String} solution_name 解决方案名称
     * @apiParam {Number} category_id  分类ID
     * @apiParam {Number} sub_id  子分类ID
     * @apiParam {Object[]} resource  资源对象 
     * @apiParam {String} resource.resource_content 描述文本字符串，可为空
     * @apiParam {String} resource.resource_name  文本标题
     * @apiParam {String} resource.resource_url  资源路径
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * 
     */
     /**
     * 过程：
     * 修改解决方案字段，删除资源记录数据，删除对应资源文件
     */
    async update(){
        const {ctx,app} = this;
        let {body}=ctx.request;
        let {Solution,Resource}=app.model;
        if(!body.solution_id){
            return ctx.body=ctx.helper.error_result("没有指定需要修改的解决方案ID")
        }
        let update_obj=ctx.helper.assign_basic({},body);
        try {
            let result=await Solution.update({...update_obj},{where:{solution_id:body.solution_id}});
            if(result){
                if(body.resource&&body.resource.length>0){
                    await Resource.destroy({where:{parent_id:body.solution_id,type:2}});
                    let resources=body.resource;
                    if(resources&&resources.length>0){
                        // resources.forEach(element => {
                        //     element['type']=2;
                        //     element['parent_id']=body.solution_id;
                        // });
                        // await app.model.Resource.bulkCreate(resources);
                        await ctx.service.common.set_resource(resources,{type:2,parent_id:body.solution_id,resource_name:body.solution_name})
                    }
                }
                return ctx.body=ctx.helper.success_result("修改解决方案成功");
            }
        } catch (error) {
        }
        ctx.body=ctx.helper.error_result("修改解决方案失败");
    }
    
    //删除解决方案
    /**
     * @api {post} /manage/solution_del 解决方案删除
     * @apiName manageSolutionDel
     * @apiGroup Solution
     * @apiVersion 1.0.0
     * @apiDescription 解决方案删除
     * @apiParam {Number} solution_id  解决方案ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * 
     */
    async del(){
        const {ctx,app} = this;
        let {body}=ctx.request;
        let {Solution,Resource}=app.model;
        if(!body.solution_id){
            return ctx.body=ctx.helper.error_result("没有指定需要修改的解决方案ID")
        } 
        try {
            let del_condition={where:{parent_id:body.solution_id,type:2}};
            let resources=await Resource.findAll(del_condition);
            if(resources.length>0){
                await Resource.destroy(del_condition)
                resources.map(ele=>{
                    
                    this.service.common.un_link_file(ele['resource_url'])
                });
            }
            let result=await Solution.destroy({where:{solution_id:body.solution_id}});
            console.log(result);
            if(result){
                return ctx.body=ctx.helper.success_result("删除成功");
            }else{
                return ctx.body=ctx.helper.success_result("未删除数据");
            }
        } catch (error) {
            console.log(error);
        }
        ctx.body=ctx.helper.error_result("删除解决方案失败")
    }
    //解决方案新增
    /**
     * @api {get} /manage/solution_add 解决方案新增
     * @apiName manageSolutionAdd
     * @apiGroup Solution
     * @apiVersion 1.0.0
     * @apiDescription 解决方案新增
     * @apiParam {String} solution_name 解决方案名称
     * @apiParam {Number} category_id  类型ID
     * @apiParam {Number} sub_id  子类型ID
     * @apiParam {Object[]} resource  资源对象 
     * @apiParam {String} resource.resource_content 描述文本字符串，可为空
     * @apiParam {String} resource.resource_name  文本标题
     * @apiParam {String} resource.resource_url  资源路径
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * 
     */
    async add(){
        const {ctx,app} = this;
        let {body}=ctx.request;
        let solution={
            solution_name:body.solution_name,
            category_id:body.category_id,
            sub_id:body.sub_id
        }
        try {
            let result=await app.model.Solution.create(solution);
            let solution_id=result['solution_id'];
            let resources=body.resource;
            if(resources&&resources.length>0){
                // resources.forEach(element => {
                //     element['type']=2;
                //     element['parent_id']=solution_id;
                // });
                // await app.model.Resource.bulkCreate(resources);
                await ctx.service.common.set_resource(resources,{type:2,parent_id:solution_id,resource_name:body.solution_name})
            }
            ctx.body=ctx.helper.success_result("添加解决方案成功");
        } catch (error) {
            ctx.body=ctx.helper.error_result("添加解决方案失败");
        }
    }

}

